New Star Software Collection/NSS_Collection.iso/3-069 qemm 603/1.ima/DVMAN/CH5.DEV

Text File | 1991-10-08 | 29.3 KB | 775 lines

Chapter 5

Learn: DESQView's Keystroke Macro Feature

 One of DESQview's most powerful features is Learn. You use Learn
to tell DESQview to remember a sequence of your keystrokes and to
assign these keystrokes to a particular key on your keyboard.
Then, whenever you want, you can play back these keystrokes by
pressing the assigned key.

A sequence of remembered keystrokes is called a script or a
keystroke macro. The key to which you've assigned a script is
called the mapped key.  It's mapped because, when you press it,
DESQview maps ~dash~ translates ~dash~ the key into the script.

Once you've assigned a script to a key, the key's previous use
(if any) is replaced by the script, as long as you're in the same
context as you were when the script was created. By "in the same
context" we mean:

~Item~ If you created the script while running a program, the
script will be associated with that program.  For example, if you
created a script while in Lotus 1-2-3 ~dash~ and assigned it to
the Ctrl-X key, then whenever, you're running 1-2-3 in DESQview,
pressing Ctrl-X will play back the script.

~Item~ If you created the script while a DESQview menu was
displayed and assigned it, for example, to the F1 key, then
whenever a DESQview menu is displayed and you press the F1 key,
the script is played back.

In order to start and finish scripts, DESQview requires a special
key, which we call the Learn key. By default, this is the Shift-
DESQ ~dash~ that is, the keystroke formed by holding down the
Shift key and tapping the DESQ key ~dash~ as the Learn key. This
displays the Learn menu, from which you select the Learn action
you want. You may redefine this key using DESQview Setup, if you
wish.

 Scripts are loaded automatically by DESQview. When you start up
DESQview, the scripts you created on DESQview menus are loaded.
When you start up a program, scripts you created for the program
are loaded.

~Heading~ Learning a Script

 The basic steps to learn a script are:

~Item~ Get your program to the point where you're ready to type
the first keystroke of the script. Or, if you want to create a
script that works  when a DESQview menu is displayed, display the
DESQview menu you want.

~Item~ Display the Learn menu and select Start Script. Then tell
DESQview which key you want to use. Also, if you like, you can
give the script a descriptive name, like "Load Report." This name
will appear on the menu of scripts displayed when Display Scripts
is selected from the Learn menu.

~Item~ Enter all the keystrokes for the script. DESQview will
remember these keystrokes as you enter them.

~Item~ Display the Learn menu again and select Finish Script.

The script is now operational. To play it back,  just press the
key(s) to which it is mapped or you may select  it from the
Display Scripts menu.

~Subhead~ Starting a Learn

 The first step in creating a script is to tell DESQview you want
to start a Learn operation. After you've reached the point where
you're ready to enter the first keystroke of the script:

~Step~ Hold down the Shift key and tap the DESQ key to display
the Learn menu.

We call Shift-DESQ the Learn key. There is no mouse equivalent.
You must start a Learn from the keyboard.

~Step~ Select Start Script. You can do this using either the
keyboard or the mouse.

The following message appears:

    Press the Key You
    Want to Redefine

~Step~ Press the key you want to use ~dash~ for example, the F1
key.

The Start a Script menu appears.

 DESQview recognizes two types of keys. Typewriter keys
correspond to the text that appears on the screen when you type-
~dash~ namely, the letters, numbers, and common symbols. Special
keys correspond to actions ~dash~ such as <Enter>, Backspace, F1,
Alt-M, Ctrl- X, and so forth. They don't have a standard text (or
screen) representation.

 In the actual script file, DESQview represents special keys as
the key name in curly brackets ~dash~ for example, {Enter},
{BackSpace}, {F1}, {Alt-M}, {Ctrl- X}, and so forth. See Appendix
I for a list of the keys DESQview uses and for information on
which keys can and cannot be redefined.

You may optionally give the script a name. We recommend you do so
to help remind you what the script does. You can display a menu
of the scripts you've create by selecting the Display Scripts
command from the Learn menu  ( see page 92). If you have
previously defined a script for that key, its name will appear in
the name field.

~Step~ If you want your script to have a name, type that name.

 If the name you enter starts with an exclamation point (!), the
script becomes a startup script. See page 92.

~Step~ Select LEARN Script.

The Start a Script menu disappears. Everything you type, until
you press the Learn key again, is recorded as part of the script.

 To cancel the Learn: Instead of selecting LEARN Script, press
Tab and then type C.

~Subhead~ Entering the Script

~Step~ Perform whatever action you want to be recorded as the
script.

All the keystrokes you type are remembered by DESQview, up to the
limit of the Learn Scripts buffer. DESQview clicks after each
keystroke to remind you that it's learning. (Clicks may be hard
to hear on a noisy keyboard.)

 A script is saved in the Learn Scripts buffer while you're
learning it. When you finish the Learn operation, it's
transferred to the Program Scripts buffer.  There is a Program
Scripts buffer for each program and one for scripts you create on
DESQview menus. You can control the size of these buffers (larger
buffers use more memory). See Appendix A for more information.

~Subhead~ Nesting Scripts

 Scripts can be "nested" ~dash~ that is, while you're learning a
script, you can enter the mapped key of another, previously
defined, script. The only limit is the length of the Learn
Scripts and Program Scripts buffers which must be large enough to
contain both.

~Subhead~ Finishing the Script

When you've finished the last keystroke of the action you want to
record, finish the Learn:

~Step~ Press the Learn key (Shift-DESQ) to redisplay the Learn
menu.

~Step~ Select Finish Script.

The script is completed and assigned to the key you selected
~dash~ for example, the F1 key.

 Remember, you must always finish (or cancel) a script once you
start it.  If you don't, when the Learn Scripts buffer is full, a
loud beep will sound each time you press a key ~dash~ until you
redisplay the Learn menu and either finish or cancel the script.

 To cancel the Learn:  Instead of selecting Finish Script, select
Cancel Learn. If you've already finished the script, the only way
to cancel it is to delete it ~dash~ see page 92.

 The Script is saved in the script buffer.

~Heading~ Playing Back a Script

 Once you've learned a script, you can play it back at any time.
If the script was learned for a particular program, you can play
it back, whenever you're working in that program. If the script
was learned on a DESQview menu, you can play it back when any
DESQview menu is displayed.

~Step~ For a program script, move the cursor to the point in the
program where you want to play back the script. For a DESQview
script, display the DESQview menu on which you want to start
playing back the script.

~Step~ Press the key you assigned to the script ~dash~ for
example, the F1 key.

 DESQview types the keystrokes it previously remembered.

 When a script is played back, it's loaded into the Playback
Scripts buffer for that program ~dash~ the entire script must
fit. If the script plays back another script, that script is also
loaded into the Playback Scripts buffer (in its entirety) at the
time it's referenced. The initial length of this buffer is 1,024
bytes. You can change its length using the Setup program (see
Appendix A).

 You can stop the playback of a script by pressing the Ctrl-Break
key. You can perform the mapped key's original function, rather
than play back the script assigned to the key, by typing `
immediately before the mapped key. You may reassign which key
DESQview uses for the Quoting character from the Setup program,
if you wish.

~Heading~ Pausing During a Script

 Often you need to create a script that will temporarily stop
during playback to allow you to enter variable information ~dash~
for example, a file name ~dash~ or to wait for some action to
complete, such as a spreadsheet recalculation.

DESQview allows you to stop playback by entering a pause in a
script. A pause  tells DESQview that,while playing back the
script, it should stop and either let you type in variable
information or wait for a fixed length of time. There are four
kinds of pauses:

~Item~ A fixed-size pause allows you to type a fixed number of
characters such as a phone number or other information of fixed
length.

~Item~ A variable pause allows you to type any number of
characters. (You signal you're done by pressing <Enter>.)

~Item~ An embedded learn works like a variable pause except that
you may embed, or nest it within the script you are currently
learning and it will be saved and mapped to another specified
key. This enables your scripts to request variable information
from the user, which can then be played back within the execution
of the outer script. The embedded learn additionally becomes a
new script which can also be played back independently. This is
useful, for example, to capture keystrokes, such as a file name,
which you need to reuse several times.

~Item~ A time delay halts playback for a given number of seconds.
This is useful for programs that ignore what you type while
certain operations are in progress ~dash~ for example, saving a
file to disk. The script resumes after the timed pause.

~Subhead~ Defining a Fixed-Size Pause

 A fixed-size pause tells DESQview that when the script is played
back, you want to pause playback, type a fixed number of
characters, and have the script resume automatically. This would
be useful, for instance, to ask the user for an eight character
file name to which the script would add the extension. To define
a fixed-size pause:

~Step~ Start your script. Then enter keystrokes until you reach
the point where you want to start the pause.

~Step~ Press the Learn key (Shift-DESQ) to display the Learn
menu.

~Step~ Select Fixed-Size Pause.

The menu disappears and you're back where you were.

~Step~ Type the text you want in the pause.

DESQview will count the number of characters you type. When
you've entered all the pause text:

~Step~ Display the Learn menu and select Fixed-Size Pause again.

DESQview finishes the pause and resumes learning the script.

~Subhead~ Playing Back a Fixed-Size Pause

 When you play back a script with a fixed-size pause in it,
DESQview stops at the point where you defined the pause:

~Step~ Type the correct number of characters.

After you type the last character of the pause, the script
resumes playing back.

~Subhead~ Defining a Variable Pause

 A variable pause tells DESQview that, when the script is played
back, you want to temporarily stop playback, type a variable
number of characters, and then resume the script when you signal,
by pressing the Enter key, that you've entered all the variable
information. This would be useful, for instance, to ask the user
to supply a file name of any length and then automatically add
the extension. To define a variable pause:

~Step~ Start your script. Then enter keystrokes until you reach
the point where you want to start the pause.

~Step~ Press the Learn key (Shift-DESQ) to display the Learn
menu.

~Step~ Select Variable Pause.

~Step~ Type the text you want in the pause.

~Step~ Display the Learn menu and select Variable Pause again.

This terminates the Variable Pause and DESQview  resumes learning
the script.

To use the Enter key in a variable pause, you must precede it
with the Quoting character (`). Otherwise, Enter will terminate
the variable pause.

~Subhead~ Playing Back a Variable Pause

 When you play back a variable pause, DESQview stops at the point
where you defined the pause:

~Step~ Type whatever variable information you want, of any
length.

Since DESQview has no way of automatically determining when
you're finished typing the variable information, you must
indicate when you're done:

~Step~ Press <Enter> when you've entered all the text you want.

The script resumes playing back.

 The <Enter> you press to complete a variable pause only tells
Learn to resume playing back the rest of the script. It doesn't
become part of the script and is never seen by the program in
which the script is being played back.

~Subhead~ Defining a Script with an Embedded Learn

 An embedded learn in a script tells DESQview that, when the
script is played back, you want to temporarily stop playback,
type a variable number of keystrokes, and then resume the script
when you signal that you've entered all the variable information
~dash~ and, in addition, that you want the variable information
you typed to be assigned to a key so that it can be used again.
The mapped key for the embedded learn may be used again within
the script being currently learned as well as independently.

The steps for creating an embedded learn within a script are
basically the same as for learning a script:

~Step~ Start your outer script. Then enter keystrokes until you
reach the point where you want to start the embedded learn in the
script.

~Step~ Press the Learn key (Shift-DESQ) to display the Learn
menu.

~Step~ Select Start Script again.

~Step~ Press the key you want to use ~dash~ for example, the F2
key.

~Step~ If you want your embedded script to have a name, supply a
name.

This will be useful if you want to use the spawned script outside
the script in which it was embedded.

~Step~ Select LEARN Script.

~Step~ Type whatever variable information you want, of any
length.

~Step~ Press the Learn key (Shift-DESQ) to display the Learn menu
again.

~Step~ Select Finish Script to complete the embedded learn.

DESQview completes learning the embedded script and assigns the
keystrokes it remembered to the key you selected ~dash~ in this
example, the F2 key. Then, DESQview resumes learning the original
script. Type more keystrokes, as necessary to your operation.

~Step~ Select Finish Script again to complete the outer script.

Now, whenever you press the F2 key, the information you just
entered will be played back ~dash~ until you replay the original
script again. When you do that, the script assigned to the F2 key
is redefined to the new variable information you enter. For an
example of  the implications of using the embedded script as part
of the outer script, see the following page.

 See pages 108-109 of Chapter 6, Advanced Mark and Transfer, for
an example of a script that uses embedded learn (to two levels)
to mark a 200-line table and then transfer it into 1-2-3 in a
single step.

~Subhead~ Playing Back an Embedded Learn

 When you play back a script with an embedded learn in it,
DESQview pauses at the point where you defined the embedded
learn:

~Step~ Type whatever variable information you want, of any
length.

~Step~ Press <Enter> when you've entered all the text you want.

If you need to use the Enter key within the pause, you may do so,
but you must precede it with the quoting key (`).

The variable information you just typed replaces the information
that was previously assigned to the key you selected ~dash~ for
example, the F2 key ~dash~ and DESQview then resumes playing back
the original script. Now, whenever you press the F2 key, the new
information you just entered will be played back.  The script
previously assigned to the F2 key is discarded.

 For example, to create a script on the F1 key that copies a
group of document files (xxx*.DOC) to a floppy, deletes any
related backup files (xxx.BAK), then lists the files on floppy as
verification, you could use an embedded learn. Start the original
learn, F1. At the point where you're ready to enter the file name
for the first time, start an embedded learn , F2, then type the
file name and end the embedded learn. You'll then continue with
the original Learn, F1, and when you need the file name again,
press the F2 key.  Don't forget to end the original learn.
Symbolically, your script would be represented as:

      {F1}=COPY {F2}=<filename>.DOC  A:{Enter}
      DEL {F2}.BAK {Enter}
      DIR  A:{F2}.DOC {Enter}

 If you want to be sure you don't accidentally press the F2 key
later, you could assign the script created by the embedded learn
to a more obscure key ~dash~ for example, Ctrl-^.

 Every time you ran the F1 script, it would pause, allow you to
enter the filename, and remember (play back) the contents of F2
within the execution of the outer script, F1.

~Subhead~ Creating a Time Delay

 A time delay tells DESQview that, when the script is played
back, you want to temporarily stop playback, wait a fixed number
of seconds, and then have the script resume automatically. To
define a timed delay:

~Step~ Start your script. Then enter keystrokes until you reach
the point where you want a time delay.

~Step~ Press the Learn key (Shift-DESQ) to display the Learn
menu.

~Step~ Select the Time Delay to display the Time Delay menu.

~Step~ Type the number of seconds you want the script to wait and
then select LEARN Time Delay.

When you play back the script, it will halt at the point where
you entered the time delay, for the number of seconds you
indicated, and then automatically resume playing back.

 You can end the time delay early by pressing <Enter>.

~Heading~ Loading and Saving Scripts

 When you create scripts, they're stored in your computer's
memory. The areas set aside for scripts are called script
buffers. There is a script buffer for each program running and
one for the scripts you create on DESQview menus.

When you close a program the script buffer for that program is
discarded and all scripts are lost ~dash~ unless you saved the
scripts first. (You'll be reminded.) When you quit DESQview, all
script buffers are discarded and all unsaved scripts are lost.

You save the scripts you've created with the Save Scripts command
on the Learn menu. You must save the scripts for each program and
for DESQview menus separately.

 While a script is being learned, it's stored in the Learn
Scripts buffer. When the script is complete, it's transferred to
the Program Scripts buffer or to the DESQview Scripts buffer.
Initially, the Learn Scripts buffer and each Program Scripts
buffers is 1,024 bytes long. The script buffer size is cumulative
~dash~  it's the maximum limit for all scripts you create for a
program or for all scripts you create on all DESQview menus.

 You can change the Program Scripts buffer size using the Change
a Program command (see Chapter 7). You can change the Learn
Scripts buffer size and the DESQview Scripts buffer size by
running the Setup program (see Appendix A).

~Subhead~ Loading Scripts

 When you start up DESQview, the scripts you created on DESQview
menus are automatically loaded (if any). Then, each time you
start up a program, the scripts for that program are
automatically loaded (if any).

~Begin footnote~

Only the scripts in a script file conforming to the naming
convention described here are loaded automatically.

~End footnote~

You can also tell DESQview to explicitly load the DESQview
scripts or the scripts for a program. This is useful, for
example, after you've modified a script with the Convert a Script
program (see Appendix I) or if you have several different sets of
scripts for the same program. To explicitly load scripts:

~Step~ For application-specific scripts, make the program you
want to load the scripts for the current window, if you aren't
already working in it. To load the DESQview scripts, display the
DESQview menu.

~Step~ Display the Learn menu and select Load Scripts.

The Load Scripts menu appears with the standard script file name
filled into the File field. For DESQview scripts, the standard
file name is DESQVIEW.DVS. For a program, the standard file name
is xx-SCRIP.DVS, where xx are the keys used to select the program
from the Open Window menu. (This guarantees that the file name is
unique.) Script files are assumed to be stored on the drive and
directory from which you started up DESQview (most commonly,
C:\DV) unless you explicitly specify a drive and directory.

 For information on managing scripts on a floppy-based system,
see Appendix D.

~Step~ Change the file name, as may be required.

~Step~ Select LOAD Scripts.

The script file you specified is loaded, replacing the DESQview
or programs scripts that are currently loaded (if any). Any
changes you made to these scripts are lost unless you previously
saved them using the Save Scripts command.

~Subhead~ Saving Scripts

 The scripts you create are stored in your computer's memory.
They're not saved to disk automatically until you explicitly tell
DESQview to do so.  (However, you are reminded to do so when you
close down a program or quit DESQview.) To save scripts:

~Step~ Resume working in the program you want to save scripts
for, if you aren't already working in it. Or, to save the
DESQview scripts, display any DESQview menu.

~Step~ Display the Learn menu and select Save Scripts.

The Save Scripts menu appears with the standard script file name
filled into the File field ~dash~ or, if you loaded these scripts
with the Load Scripts command, the File field contains the file
name you used. For DESQview scripts, the standard file name is
DESQVIEW.DVS. For a program, the standard file name is xx-
SCRIP.DVS, where xx are the keys used to select the program from
the Open Window menu.

~Step~ Change the file name, as you require.

However, we recommend that you do not change the file name unless
you're creating multiple sets of scripts for a program or for
DESQview ~dash~ because only the script files named DESQVIEW.DVS
and xx- SCRIP.DVS will be automatically loaded when DESQview or
the program is started up. If you give the script file any other
name, it can only be loaded manually, with the Load Scripts
command.

~Step~ Select SAVE Scripts.

The scripts you specified are saved to disk under the name you
specified ~dash~ on the drive and directory from which you
started up DESQview (most commonly, C:\DV) unless you explicitly
specify a drive and directory to use.

~Subhead~ Saving Scripts Containing an Embedded Learn

 When a script containing an embedded learn is saved for the
first time, the contents and key assignment of the embedded learn
is saved with it. If you always wish to save the contents of the
embedded learn, you must thereafter explicitly save the scripts
for that program. DESQview will not interpret a change in the
embedded variable keystrokes as a "new" script. This is only
noteworthy if you intend to retain the contents of the embedded
script  and you wish to use it for the next session.

~Heading~ Other Learn Features

 Learn has several additional features:

~Item~ You can delete a script you no longer want.

~Item~ You can display a menu listing of all the scripts you've
created for DESQview and for each program and optionally choose
and execute a script from this menu.

~Item~ You can define a startup script for DESQview and for each
program.

~Item~ You can use the ` (Quoting) key to override a key
redefinition and the Ctrl- Break key to abort the playback of a
script.

~Item~ You can edit or debug a script using the Convert a Script
program to convert a script file into a text (ASCII) file.  You
can then edit the script in any text editor or word processor
that reads and writes a plain ASCII file. Convert a Script also
reads a text file and converts it into a script file when you are
done editing.

~Item~ You can use DESQview Notepad Companion,

~Begin footnote~

Available separately from Quarterdeck Office Systems

~End footnote~

if you have it, to edit script files. Conversion of script
files is automatic when using Notepad.

~Subhead~ Deleting a Script

 You delete a script by re-learning an empty script for the key
you mapped.

~Step~ Display the Learn menu and select Start Script.

~Step~ Press the key for the script you want to delete

~Step~ Select LEARN Script.

Now, immediately end the Learn:

~Step~ Display the Learn menu again and select Finish Script.

The key you used for the script is now restored to its normal
usage.

~Subhead~ Getting a List of Scripts

 To see a list of all scripts you've created:

~Step~ Display the Learn menu and select Display Scripts.

A menu listing the scripts you've created appears. Both the key
and the name you gave to the script in the Script Name field (if
any) are shown.

~Step~ Select the script you want to delete ~dash~ or press Esc
to remove the menu.

~Subhead~ Defining a Startup Script

 You can specify a script to be a startup script. A startup
script is executed when you start up a program or start up
DESQview, as well as when you press the key you assigned to the
script.

To create a startup script, learn a script in the normal manner.
But, when the Start a Script menu appears, enter a name that
begins with an exclamation point (!) in the Script Name field
~dash~  for example, !Startup DESQview. Now, this script will
automatically be performed when the program or DESQview is
started up.

To be sure you startup script plays back properly:

~Item~ When you learn a program startup script, be sure to learn
it immediately after starting up the program.

~Item~ When you learn a DESQview startup script, be sure to learn
it with no windows open and with the DESQview menu displayed.

DESQview also recognizes an alternate method of defining the
DESQview startup script ~dash~ assigning a DESQview script to the
exclamation point (!) key. Only DESQview scripts function as
startup scripts when assigned to the ! key. This doesn't apply to
program scripts.

~Subhead~ Special Learn Keys

 DESQview recognizes three special keys for learn:

~Item~ The Learn key (Shift-DESQ) displays the Learn menu ~dash~
which is your starting point for all Learn operations, except
playback. See page 36 for more information.

~Item~ The  ` (Quoting key) overrides a key redefinition.
Normally, when you press a key you've redefined ~dash~ for
example, the F1 key ~dash~ the key performs the script you
learned for that key. However, if you press the ` key immediately
before the F1 key, the original action of the F1 key, is
performed instead. See page 40 for more information. You may
redefine the Learn key, Quoting key, and other DESQview system
keys as well, in the DESQview Setup program (see appendix A).

 The Ctrl-Break key stops (aborts) the playback of a script. When
you press Ctrl-Break while a script is being played back, the
script is aborted. (If you press Ctrl-Break at any other time,
it's acted upon by the program.)  See page 41 for more
information.

~Heading~ The Convert a Script Program

 The scripts you create are written to disk in a special, encoded
format. Sometimes it's useful to be able to edit them, or to
create your own scripts directly with a word processor. The
Convert a Script program lets you do this.

When you run the Convert a Script program, you can read a script
file written by the Save Scripts command, or convert a script you
prepared with your word processor (as an ASCII text file) into
the format of a script file.

To run Convert a Script, first use Add a Program to install it on
the Open Window Menu. Convert a Script is in your DESQview
directory (CONVSCR.COM).

~Subhead~ Getting Started

 Appendix I, Editing DESQview Scripts, discusses the Convert a
Script program in detail and lists all the keys you can use (or
can't use) in creating scripts. Basically, the easiest way to
learn how to use Convert a Script is:

~Item~ Create a few scripts for a program you're familiar with
~dash~ such as Lotus 1-2-3.

~Item~ Save these scripts to a file using the Save Scripts
command. Note the name of the file that appears when you display
the Save Scripts menu ~dash~ for example, L2-SCRIPT.DVS. A
DESQview startup script is named DESQVIEW.DVS.

~Item~ Edit the scripts:

 ~dash~  If you have the DESQview Notepad Companion,

~Begin footnote~

Available separately from Quarterdeck Office Systems

~End footnote~

you can edit script files directly. Just edit the file \DV\L2-
SCRIP.DVS in non-document mode (see Appendix I for more
information).

 ~dash~  If you don't have the DESQview Notepad Companion, run
Convert a Script to convert the scripts you saved to a text
(ASCII) file, edit them with your word processor,

~Begin footnote~

When you save the file be sure to save it as raw ASCII text,
without any formatting  or embedded control characters.

~End footnote~

then run Convert a Script again to convert them back to script
file format.

~Item~ Load the edited scripts back into DESQview using the Load
Scripts command.

Repeat this process until the scripts work the way you want.

~Subhead~ Directly Creating a Script

 You can also create a script directly with the DESQview Notepad
Companion or with your favorite word processor. Enter a list of
key definitions (see Appendix I). If you're not using Notepad,
save these definitions to a file~dagger~~dagger~ and run Convert
a Script to convert this file to script file format.